/*
 * @Author: wuqingchun
 * @Date: 2024-12-03 21:01:07
 * @Description: 
 * @LastEditors: wuqingchun
 * @LastEditTime: 2024-12-04 20:19:26
 */

#include <type_traits>
#include <cstddef>
#include <iostream>
#include <tuple>
#include <string>

// // 假设的参数存储类
// template <typename... Args>
// class format_arg_store {
// public:
//     // 构造函数，接受参数包
//     constexpr format_arg_store(Args&&... args) : args_(std::forward<Args>(args)...) {}

//     // 获取参数
//     template <typename T, size_t Idx>
//     const T& get() const {
//         return std::get<Idx>(args_);
//     }

// private:
//     std::tuple<Args...> args_;
// };


template <typename... Args>
std::string format_string(std::string Fmt, Args&&... args)
{
    std::tuple<Args&&...> argsTuple(std::forward<Args>(args)...);

    std::string strResult;

    std::cout << "begin: " <<  Fmt << std::endl;

    size_t luIndex = 0;
    while (!Fmt.empty())
    {
        std::size_t luPos = Fmt.find("{}");
        if (luPos == std::string::npos)
        {
            strResult += Fmt;
            break;
        }
        else
        {
            strResult += Fmt.substr(0, luPos);

            //std::get<luIndex>(argsTuple);
            Fmt = Fmt.substr(luPos + 2);
        }
    }
    
    std::cout << "end: " <<  strResult << std::endl;

    return strResult;
}


// #include <iostream>
// #include <sstream>
// #include <string>
// #include <tuple>
// #include <utility>

// // 辅助函数，用于检查并替换字符串中的占位符
// std::string replace_placeholder(std::string& str, size_t& pos, const std::string& replacement) {
//     size_t start = pos;
//     pos = str.find('%', pos + 1); // 寻找下一个 '%' 字符
//     if (pos == std::string::npos) {
//         // 如果没有找到，则使用整个剩余字符串作为占位符（这通常意味着格式字符串有误）
//         pos = str.size();
//     } else {
//         // 提取占位符（例如 "%s" 或 "%d"）
//         std::string placeholder = str.substr(start, pos - start);
        
//         // 根据占位符类型进行替换
//         if (placeholder == "%s") {
//             // 这里假设我们有一个字符串参数，但实际上我们需要从 args 中获取它
//             // 由于此示例的简化性，我们直接返回 replacement（在实际实现中，这将来自 args）
//             str.replace(start, pos - start, replacement);
//         } else if (placeholder == "%d") {
//             // 同样，这里应该有一个整数参数，但为简化起见，我们直接返回 "0"（在实际中会从 args 获取）
//             std::ostringstream oss;
//             oss << 0; // 应替换为从 args 中获取的整数
//             str.replace(start, pos - start, oss.str());
//             // 注意：在实际应用中，你需要确保 args 中有足够且正确类型的参数来替换所有占位符
//         }
//         // 注意：此示例未处理错误情况（如缺少参数、参数类型不匹配等）
//     }
//     return str;
// }

// // 格式化函数模板，接受格式字符串和可变参数
// template <typename... Args>
// std::string format_string(std::string fmt, Args&&... args) {
//     size_t pos = 0;
//     std::tuple<Args&&...> args_tuple(std::forward<Args>(args)...);
    
//     // 注意：此处的实现过于简化，未真正从 args_tuple 中提取并使用参数
//     // 仅为示例，展示如何遍历并尝试替换占位符
    
//     // 实际上，你需要编写一个递归或迭代函数来处理 args_tuple 中的每个参数
//     // 但由于示例的简化性，我们仅模拟替换第一个出现的 "%s" 为 "example"（假设有一个字符串参数）
//     // 和第一个出现的 "%d" 为 "0"（假设有一个整数参数）
    
//     // 模拟替换第一个 "%s"
//     if ((pos = fmt.find("%s")) != std::string::npos) {
//         fmt = replace_placeholder(fmt, pos, "example"); // 在实际中，这里应使用 args_tuple 中的参数
//     }
    
//     // 模拟替换第一个 "%d"
//     if ((pos = fmt.find("%d")) != std::string::npos) {
//         fmt = replace_placeholder(fmt, pos, "0"); // 在实际中，这里应使用 args_tuple 中的参数
//     }
    
//     // 注意：此示例并未真正处理可变参数，且仅模拟了替换过程
//     // 在实际实现中，你需要遍历 args_tuple，并根据占位符的类型和顺序来替换它们
    
//     return fmt;
// }

int main() {
    std::string result = format_string("Hello, {}! You have {} new messages.", "Alice", 5);
    std::cout << result << std::endl; // 输出应为 "Hello, example! You have 0 new messages."，但应为 "Hello, Alice! You have 5 new messages." 在实际实现中
    return 0;
}


// int main(int argc, char** argv)
// {
//     std::tuple<int, double> store(1, 2.0);

//     std::cout << std::get<0>(store) << std::endl;
//     std::cout << std::get<1>(store) << std::endl;


//     format_arg_store<int, double, std::string> st(1, 2.1, "aaaaa");
//     std::cout << st.get<int, 0>() << std::endl;
//     std::cout << st.get<double, 1>() << std::endl;
//     std::cout << st.get<std::string, 2>() << std::endl;


//     format_string("aaa={}, bbb={}, ccc={}", 1, 2.1, "300");
    
// }
